import json
import random
import time
import secrets
from sqlite3 import IntegrityError

from django.shortcuts import render
from django.views import View
from .models import *
from django.http import JsonResponse
from django.core.cache import cache
from django.forms.models import model_to_dict
from .models import UploadedImage
from django.contrib.auth.hashers import make_password #加密第三方库
import uuid
import os
# from aliyunsdkcore.client import AcsClient
# from aliyunsdkcore.acs_exception.exceptions import ClientException
# from aliyunsdkcore.acs_exception.exceptions import ServerException
# from aliyunsdkdysmsapi.request.v20170525.SendSmsRequest import SendSmsRequest
# 文心一言ai接口
# import requests
from django.views.decorators.csrf import csrf_exempt
from django.conf import settings
import logging
import base64

logger = logging.getLogger(__name__)
# 存储用户会话状态
user_sessions = {}


# 排组的介绍
# 关键字校验
# 注册
import mimetypes
from django.core.files.storage import default_storage
from django.utils.decorators import method_decorator
# Create your views here.
#文件上传


MAX_FILE_SIZE = 10 * 1024 * 1024  # 最大文件大小为 10MB
# 允许上传的文件类型
ALLOWED_FILE_TYPES = {
    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
    '.mp4': 'video/mp4',
    '.txt': 'text/plain'
}
@method_decorator(csrf_exempt, name='dispatch')
class UploadFileView(View):
    def post(self, request):
        file = request.FILES.get('file')
        if file:
            # 验证文件大小
            if file.size > MAX_FILE_SIZE:
                return JsonResponse({'message': '文件大小超过限制'})
            # 验证文件类型
            file_type, _ = mimetypes.guess_type(file.name)
            file_extension = '.' + file.name.split('.')[-1].lower()
            if file_extension not in ALLOWED_FILE_TYPES or file_type != ALLOWED_FILE_TYPES[file_extension]:
                return JsonResponse({'message': '不支持的文件类型'})

            chunk_size = 2 * 1024 * 1024
            file_name = file.name
            file_path = f'uploads/{file_name}'
            try:
                with default_storage.open(file_path, 'wb') as destination:
                    for chunk in file.chunks(chunk_size):
                        destination.write(chunk)
                return JsonResponse({'message': '文件上传成功'})
            except Exception as e:
                return JsonResponse({'message': f'文件上传失败: {str(e)}'})
        return JsonResponse({'message': '请用 POST 方式上传文件'})
class BackView(View):
    def post(self,request):
        data=Background.objects.all()
        lasd=[]
        for i in data:
            lasd.append({
                'id':i.id,
                'name':i.name,
                'back_url':i.back_url,
                'content':i.content
            })
        return  JsonResponse({'code':200,'data':lasd})
#活动的创建
# 创建活动
# 创建活动的视图函数，使用 @csrf_exempt 装饰器豁免 CSRF 验证
@csrf_exempt
def create_activity(request):
    """
    处理创建活动的请求
    :param request: Django 的 HttpRequest 对象，包含请求的相关信息
    """
    if request.method == 'POST':
        try:
            # 从请求体中解析 JSON 数据
            data = json.loads(request.body)
            # 从解析后的数据中获取活动名称
            activity_name = data.get('activity_name')
            # 从解析后的数据中获取活动描述
            activity_description = data.get('activity_description')
            # 从解析后的数据中获取活动开始时间
            start_time = data.get('start_time')
            # 从解析后的数据中获取活动结束时间
            end_time = data.get('end_time')

            # 检查是否缺少必要的字段（活动名称、描述、开始时间和结束时间）
            if not all([activity_name, activity_description, start_time, end_time]):
                # 如果缺少必要字段，返回错误信息和 400 状态码（请求无效）
                return JsonResponse({'error': 'Missing required fields'}, status=400)

            # 创建一个新的 Activity 对象
            new_activity = Activity(
                activity_name=activity_name,
                activity_description=activity_description,
                start_time=start_time,
                end_time=end_time
            )
            # 将新的 Activity 对象保存到数据库中
            new_activity.save()

            # 返回成功创建活动的信息，包括消息和活动 ID，状态码为 201（已创建）
            return JsonResponse({'message': '活动创建成功', 'activity_id': new_activity.id}, status=201)
        except json.JSONDecodeError:
            # 如果 JSON 数据解析失败，返回错误信息和 400 状态码（无效 JSON 数据）
            return JsonResponse({'error': 'Invalid JSON data'}, status=400)
    # 如果请求方法不是 POST，返回错误信息和 405 状态码（方法不允许）
    return JsonResponse({'error': 'Invalid request method'}, status=405)

# 添加用户到活动的视图函数，使用 @csrf_exempt 装饰器豁免 CSRF 验证
@csrf_exempt
def add_participant(request, activity_id):
    """
    处理将用户添加到活动的请求
    :param request: Django 的 HttpRequest 对象，包含请求的相关信息
    :param activity_id: 要添加用户的活动 ID
    :return: JsonResponse 对象，返回添加用户的结果信息和状态码
    """
    if request.method == 'POST':
        try:
            # 从请求体中解析 JSON 数据
            data = json.loads(request.body)
            # 从解析后的数据中获取用户 ID
            user_id = data.get('user_id')

            # 检查是否缺少用户 ID 字段
            if not user_id:
                # 如果缺少用户 ID 字段，返回错误信息和 400 状态码（请求无效）
                return JsonResponse({'error': 'Missing user_id'}, status=400)

            try:
                # 根据活动 ID 获取对应的 Activity 对象
                activity = Activity.objects.get(id=activity_id)
                # 根据用户 ID 获取对应的 YongHu（用户）对象
                user = YongHu.objects.get(id=user_id)
                # 将用户添加到活动的参与者列表中
                activity.participants.add(user)
                # 返回成功添加用户的信息，状态码为 200（成功）
                return JsonResponse({'message': '用户已成功添加到活动中'}, status=200)
            except Activity.DoesNotExist:
                # 如果活动不存在，返回错误信息和 404 状态码（未找到活动）
                return JsonResponse({'error': '活动没有找到'}, status=404)
            except YongHu.DoesNotExist:
                # 如果用户不存在，返回错误信息和 404 状态码（未找到用户）
                return JsonResponse({'error': '用户没有找到'}, status=404)
        except json.JSONDecodeError:
            # 如果 JSON 数据解析失败，返回错误信息和 400 状态码（无效 JSON 数据）
            return JsonResponse({'error': 'Invalid JSON data'}, status=400)
    # 如果请求方法不是 POST，返回错误信息和 405 状态码（方法不允许）
    return JsonResponse({'error': 'Invalid request method'}, status=405)

# 获取活动的参与者
@csrf_exempt
def get_participants(request, activity_id):
    try:
        activity = Activity.objects.get(id=activity_id)
        participants = activity.participants.all()
        participant_list = [{'id': p.id, 'username': p.name} for p in participants]
        return JsonResponse({'participants': participant_list}, status=200)
    except Activity.DoesNotExist:
        return JsonResponse({'error': '活动没有找到'}, status=404)


#排组的介绍
class Zupai(View):
    def post(self,request):#增加牌组的信息
        data=json.loads(request.body)
        info=Paizu()
        info.zuname=data['zuname']
        info.content=data['content']
        info.guan=data['guan']
        info.paitu_array=data['paitu_array']
        info.save()
        return  JsonResponse({'code':200})
    def get(self,request):#获取牌组的信息
        pz=Paizu.objects.all()
        pz_list=[]
        for i in pz:
            pz_list.append({
                'id':i.id,
                'zuname':i.zuname,
                'content':i.content,
                'guan':i.guan,
                'paitu_array':i.paitu_array
            })
        return JsonResponse({
            'code':200,
            'data':pz_list
        })

# 定义不文明字段数组
BAD_WORDS = ['不文明词1', '不文明词2']  # 可添加修改
def contains_bad_words(content):
    """
    检查内容是否包含不文明词汇
    :param content: 待检查的内容
    :return: 如果包含不文明词汇返回 True，否则返回 False
    """
    for word in BAD_WORDS:
        if word in content:
            return True
    return False

# 免除 CSRF 保护的装饰器，用于允许跨站请求
@csrf_exempt
def get_comments(request, article_id):
    try:
        # 根据文章 ID 获取对应的文章对象
        article = Article.objects.get(id=article_id)
        # 过滤出该文章下的顶级评论（没有父评论的评论）
        comments = Comment.objects.filter(article=article, parent_comment__isnull=True)
        comment_list = []
        for comment in comments:
            # 构建每个评论的信息字典
            comment_info = {
                'id': comment.id,
                'myname': comment.myname,  # 评论的用户名称
                'content': comment.content,
                # 将评论创建时间格式化为字符串
                'create_time': comment.create_time.strftime('%Y-%m-%d %H:%M:%S'),
                'user': comment.user.name,
                'replies': []
            }
            # 获取该评论的所有回复
            replies = Comment.objects.filter(parent_comment=comment)
            for reply in replies:
                # 构建每个回复的信息字典
                reply_info = {
                    'id': reply.id,
                    'myname': reply.myname,  # 回复评论的用户名称
                    'content': reply.content,
                    # 将回复创建时间格式化为字符串
                    'create_time': reply.create_time.strftime('%Y-%m-%d %H:%M:%S'),
                    'user': reply.user.name
                }
                # 将回复信息添加到对应的评论信息中
                comment_info['replies'].append(reply_info)
            # 将评论信息添加到评论列表中
            comment_list.append(comment_info)
        # 返回包含评论列表的 JSON 响应，状态码为 200 表示成功
        return JsonResponse({'comments': comment_list}, status=200)
    except Article.DoesNotExist:
        # 如果文章不存在，返回包含错误信息的 JSON 响应，状态码为 404 表示未找到
        return JsonResponse({'error': 'Article not found'}, status=404)


# 免除 CSRF 保护的装饰器，用于允许跨站请求
@csrf_exempt
def post_comment(request, article_id):
    if request.method == 'POST':
        try:
            # 解析请求体中的 JSON 数据
            data = json.loads(request.body)
            # 从解析后的数据中获取评论内容
            content = data.get('content')
            # 从解析后的数据中获取用户 ID
            user_id = data.get('user_id')
            # 从解析后的数据中获取评论的用户名称
            myname = data.get('myname')
            # 检查评论内容、用户 ID 和用户名称是否都存在，如果不存在则返回错误信息
            if not content or not user_id or not myname:
                return JsonResponse({'error': 'Content, user_id and myname are required'}, status=400)
            # 检查内容是否包含不文明词汇
            if contains_bad_words(content):
                return JsonResponse({'error': '使用文明字词'}, status=400)
            try:
                # 根据用户 ID 获取对应的用户对象
                user = YongHu.objects.get(id=user_id)
                # 根据文章 ID 获取对应的文章对象
                article = Article.objects.get(id=article_id)
                # 创建一个新的评论对象
                new_comment = Comment(content=content, user=user, article=article, myname=myname)
                # 将新评论保存到数据库中
                new_comment.save()
                # 返回包含新评论信息的 JSON 响应，状态码为 201 表示创建成功
                return JsonResponse({
                    'id': new_comment.id,
                    'myname': new_comment.myname,
                    'content': new_comment.content,
                    # 将新评论创建时间格式化为字符串
                    'create_time': new_comment.create_time.strftime('%Y-%m-%d %H:%M:%S'),
                    'user': new_comment.user.name
                }, status=201)
            except YongHu.DoesNotExist:
                # 如果用户不存在，返回包含错误信息的 JSON 响应，状态码为 404 表示未找到
                return JsonResponse({'error': 'User not found'}, status=404)
            except Article.DoesNotExist:
                # 如果文章不存在，返回包含错误信息的 JSON 响应，状态码为 404 表示未找到
                return JsonResponse({'error': 'Article not found'}, status=404)
        except json.JSONDecodeError:
            # 如果请求体的 JSON 数据解析失败，返回包含错误信息的 JSON 响应，状态码为 400 表示请求无效
            return JsonResponse({'error': 'Invalid JSON data'}, status=400)
    # 如果请求方法不是 POST，返回包含错误信息的 JSON 响应，状态码为 405 表示方法不允许
    return JsonResponse({'error': 'Invalid request method'}, status=405)


# 免除 CSRF 保护的装饰器，用于允许跨站请求
@csrf_exempt
def reply_comment(request, comment_id):
    if request.method == 'POST':
        try:
            # 解析请求体中的 JSON 数据
            data = json.loads(request.body)
            # 从解析后的数据中获取回复内容
            content = data.get('content')
            # 从解析后的数据中获取用户 ID
            user_id = data.get('user_id')
            # 从解析后的数据中获取回复评论的用户名称
            myname = data.get('myname')
            # 检查回复内容、用户 ID 和用户名称是否都存在，如果不存在则返回错误信息
            if not content or not user_id or not myname:
                return JsonResponse({'error': 'Content, user_id and myname are required'}, status=400)
            # 检查内容是否包含不文明词汇
            if contains_bad_words(content):
                return JsonResponse({'error': '使用文明字词'}, status=400)
            try:
                # 根据用户 ID 获取对应的用户对象
                user = YongHu.objects.get(id=user_id)
                # 根据评论 ID 获取对应的父评论对象
                parent_comment = Comment.objects.get(id=comment_id)
                # 创建一个新的回复评论对象，关联到父评论和对应的文章
                new_reply = Comment(content=content, user=user, article=parent_comment.article,
                                    parent_comment=parent_comment, myname=myname)
                # 将新回复保存到数据库中
                new_reply.save()
                # 返回包含新回复信息的 JSON 响应，状态码为 201 表示创建成功
                return JsonResponse({
                    'id': new_reply.id,
                    'myname': new_reply.myname,
                    'content': new_reply.content,
                    # 将新回复创建时间格式化为字符串
                    'create_time': new_reply.create_time.strftime('%Y-%m-%d %H:%M:%S'),
                    'user': new_reply.user.name
                }, status=201)
            except YongHu.DoesNotExist:
                # 如果用户不存在，返回包含错误信息的 JSON 响应，状态码为 404 表示未找到
                return JsonResponse({'error': 'User not found'}, status=404)
            except Comment.DoesNotExist:
                # 如果父评论不存在，返回包含错误信息的 JSON 响应，状态码为 404 表示未找到
                return JsonResponse({'error': 'Comment not found'}, status=404)
        except json.JSONDecodeError:
            # 如果请求体的 JSON 数据解析失败，返回包含错误信息的 JSON 响应，状态码为 400 表示请求无效
            return JsonResponse({'error': 'Invalid JSON data'}, status=400)
    # 如果请求方法不是 POST，返回包含错误信息的 JSON 响应，状态码为 405 表示方法不允许
    return JsonResponse({'error': 'Invalid request method'}, status=405)


# 注册管理员
@csrf_exempt  # 允许跨域访问
def register(request):
    response_data = {"status": "error", "message": "", "username": ""}
    if request.method == 'POST':
        name = request.POST.get('name', '').strip()
        password = request.POST.get('pwd', '')
        # 验证规则
        if not name or len(name) < 3:
            response_data['message'] = "用户名需至少3个字符"
            return JsonResponse(response_data, status=400)
        if not password or len(password) < 6:
            response_data['message'] = "密码需至少6个字符"
            return JsonResponse(response_data, status=400)
        try:
            # 强制设置权限为管理员
            user = YongHu.objects.create(
                name=name,
                pwd=make_password(password),  # 密码加密存储
                # 密码加密,第三方库
                key='2'  # 强制设定为管理员
            )
            response_data.update({
                "status": "success",
                "message": "管理员账户创建成功",
                "username": user.name
            })
            return JsonResponse(response_data, status=201)
        except IntegrityError:
            response_data['message'] = "用户名已被占用"
            return JsonResponse(response_data, status=400)
    return JsonResponse(response_data, status=405)
# 图片的上传与获取
@csrf_exempt  # 简化示例，正式环境应使用csrf验证
def upload_image(request):
    if request.method == 'POST':
        try:
            # 验证文件存在性
            if 'image' not in request.FILES:
                return JsonResponse({'status': 'error', 'message': '未上传文件'}, status=400)
            uploaded_file = request.FILES['image']
            # 文件类型验证
            allowed_types = ['image/jpeg', 'image/png', 'image/gif']
            if uploaded_file.content_type not in allowed_types:
                return JsonResponse({'status': 'error', 'message': '仅支持JPEG/PNG/GIF格式'}, status=400)
            # 生成唯一文件名
            ext = uploaded_file.name.split('.')[-1]
            unique_name = f"{uuid.uuid4().hex}.{ext}"
            # 保存文件
            instance = UploadedImage()
            instance.image.save(unique_name, uploaded_file)
            instance.save()
            # 返回本地访问URL（注意使用Django服务的实际地址和端口）
            image_url = f"http://localhost:8000{instance.image.url}"  # 默认为8000端口
            return JsonResponse({
                'status': 'success',
                'image_url': image_url,
                'file_info': {
                    'name': unique_name,
                    'size': uploaded_file.size,
                    'type': uploaded_file.content_type
                }
            })
        except Exception as e:
            return JsonResponse({'status': 'error', 'message': str(e)}, status=500)
    return JsonResponse({'status': 'error', 'message': '仅支持POST请求'}, status=405)
# 用户登录
class UserView(View):
    def generate_secure_code(self, length=8):
        """生成包含数字和大写字母的随机串"""
        charset = '234679ACDEFGHJKLMNPQRTUVWXY'  # 排除易混淆字符
        return ''.join(secrets.choice(charset) for _ in range(length))
    def post(self, request):
        try:
            # 解析请求体数据
            data = json.loads(request.body)
            name = data.get('username')
            pwd = data.get('password')
            if name and pwd:
                try:
                    user = YongHu.objects.get(name=name, pwd=pwd)  # 用户登录
                    user_dict = model_to_dict(user)  # 核心转换方法
                    verification_code = self.generate_secure_code(6)  # 生成6位验证码
                    cache_key = f'code_{name}'
                    cache.set(cache_key, verification_code, timeout=300)  # 5分钟缓存
                    response_data = {
                        'code': 200,
                        'data': {
                            'user_info': user_dict,
                            'verification_code': verification_code
                        }
                    }
                    return JsonResponse(response_data)
                except YongHu.DoesNotExist:
                    return JsonResponse({'code': 401, 'message': '用户名或密码错误'}, status=401)
            else:
                return JsonResponse({'code': 400, 'message': '请求体中缺少用户名或密码'}, status=400)

        except json.JSONDecodeError:
            return JsonResponse({'code': 400, 'message': '请求体不是有效的 JSON 数据'}, status=400)
        except Exception as e:
            return JsonResponse({'code': 500, 'message': f'服务器内部错误: {str(e)}'}, status=500)
#短信验证
# 阿里云短信配置，这里仅为示例，需要替换为真实的配置
ACCESS_KEY_ID = "LTAI5t6YGT5WAvH54HS1ujJB"
SECRET_ACCESS_KEY = "cFWsG445UraulF4L2AygCJFDsKnrw5"

# 存储验证码的字典
verification_codes = {}
# 阿里云短信签名
SIGN_NAME = "0424测试"
# 阿里云短信模板 ID
TEMPLATE_CODE = "你的短信模板 ID"
@csrf_exempt
def send_sms(request):
    if request.method == 'POST':
        try:
            # 从请求体中获取手机号
            data = json.loads(request.body)
            phone_number = data.get('phoneNumber')

            if not phone_number:
                return JsonResponse({
                    'success': False,
                    'message': '手机号不能为空'
                })

            # 生成6位随机验证码
            code = str(random.randint(100000, 999999))
            # 创建 AcsClient 实例
            # client = AcsClient(ACCESS_KEY_ID, SECRET_ACCESS_KEY, 'cn-hangzhou')
            # 创建发送短信请求
            # request = SendSmsRequest()
            # request.set_accept_format('json')
            # request.set_phone_numbers(phone_number)
            # request.set_sign_name(SIGN_NAME)
            # request.set_template_param("{\"code\":\"%s\"}" % code)
            try:
                # 这里可以集成真实的短信服务
                # 为了测试，直接返回成功
                verification_codes[phone_number] = code
                print(f'测试验证码：{code}')  # 方便测试查看验证码

                return JsonResponse({
                    'success': True,
                    'message': '验证码发送成功'
                })
            except Exception as error:
                print(f'验证码发送失败: {error}')
                return JsonResponse({
                    'success': False,
                    'message': '验证码发送失败'
                })
        except json.JSONDecodeError:
            return JsonResponse({
                'success': False,
                'message': '请求体不是有效的 JSON 格式'
            })
    return JsonResponse({
        'success': False,
        'message': '只支持 POST 请求'
    })

@csrf_exempt
def phone_login(request):
    if request.method == 'POST':
        try:
            # 从请求体中获取手机号和验证码
            data = json.loads(request.body)
            phone = data.get('phone')
            code = data.get('code')

            if not phone or not code:
                return JsonResponse({
                    'success': False,
                    'message': '手机号和验证码不能为空'
                })

            saved_code = verification_codes.get(phone)

            if not saved_code or saved_code != code:
                return JsonResponse({
                    'success': False,
                    'message': '验证码错误或已过期'
                })

            try:
                # 查找或创建用户
                user, created = YongHu.objects.get_or_create(
                    pwd=phone,
                    defaults={
                        'name': f'用户{phone[-4:]}',
                        'pwd': phone,  # 默认密码
                        'key':'1'
                    }
                )

                # 验证成功后删除验证码
                del verification_codes[phone]

                return JsonResponse({
                    'success': True,
                    'message': '登录成功',
                    'user': {
                        'id': user.id,
                        'pwd': user.pwd,
                        'name': user.name
                    }
                })
            except Exception as error:
                print(f'登录失败: {error}')
                return JsonResponse({
                    'success': False,
                    'message': '登录失败，请重试'
                })
        except json.JSONDecodeError:
            return JsonResponse({
                'success': False,
                'message': '请求体不是有效的 JSON 格式'
            })
    return JsonResponse({
        'success': False,
        'message': '只支持 POST 请求'
    })

class TuView(View):#图片的管理
    def get(self,request):
        data=Tu.objects.all()
        lasd=[]
        for i in data:
            lasd.append({
                'id':i.id,
                'tu_url':i.tu_url,
                'title':i.title,
                'content':i.content,
                'xing':i.xing,
                'guan':i.guan
            })
        return JsonResponse({'code': 200, 'data': lasd})

class TypeView(View):  # 获取对话的类型
    def get(self, request):
        data = Type.objects.all()
        lasd = []
        for i in data:
            lasd.append({
                'id': i.id,
                'tname': i.name
            })
        return JsonResponse({'code': 200, 'data': lasd,'rew':'123'})


class DaPingView(View):  # 大屏可视化部分
    def get(self, request):  # 获取数据
        data = DaPing.objects.all()
        lasd = []
        for i in data:
            lasd.append({
                'id': i.id,
                'name': i.name,
                'hang_array': i.hang_array,
                'shu_array': i.shu_array
            })
        return JsonResponse({'code': 200, 'data': lasd})

    def post(self, request):  # 提交数据并进行修改
        data = json.loads(request.body)
        info = DaPing.objects.get(id=data['id'])
        info.name = data['name']
        info.hang_array = data['hang_array']
        info.shu_array = data['shu_array']
        info.save()
        return JsonResponse({'code': 200})

    def delete(self, request):
        id = request.GET.get('id')
        DaPing.objects.get(id=id).delete()
        return JsonResponse({'code': 200})


class WenDaView(View):  # 与ai进行问答
    def post(self, request):  # 提交内容
        data = json.loads(request.body)
        info = WenDa()
        info.name = data['name']
        info.ai_array = data['ai_array']
        info.hu_array = data['hu_array']
        info.tu_array = data['tu_array']
        info.yonghu_id = data['yonghuid']
        info.type_id = data['typeid']
        info.tu_id = data['tuid']
        info.save()
        return JsonResponse({'code': 200, 'data': '添加成功'})

    def delete(self, request):
        id = request.GET.get('id')
        WenDa.objects.get(id=id).delete()
        return JsonResponse({'code': 200})

    def get(self, request):
        result = WenDa.objects.all()
        lasd = []
        for i in result:
            lasd.append({
                'id': i.id,
                'name': i.name,
                'ai_array': i.ai_array,
                'hu_array': i.hu_array,
                'tu_array': i.tu_array,
                'created_time': i.created_time,
                'yonghu': i.yonghu_id,
                'type': i.type_id,
                'tu': i.tu_id
            })
        return JsonResponse({'code': 200, 'data': lasd})


# 文心一言接口
@csrf_exempt
def wenxin_chat(request):
    if request.method == 'POST':
        try:
            data = json.loads(request.body)
            question = data.get('question', '')
            session_id = data.get('session_id', 'default')  # 用于跟踪对话状态

            # 初始化或获取会话状态
            if session_id not in user_sessions:
                user_sessions[session_id] = {
                    'waiting_for_image': False,
                    'context': []
                }

            session = user_sessions[session_id]

            # 检查是否在等待图片上传
            if session['waiting_for_image']:
                return JsonResponse({
                    'status': 'success',
                    'response': {
                        'result': '请上传您想解析的图片，我会帮您详细分析。',
                        'waiting_for_image': True
                    }
                })

            # 检查用户是否请求图片分析
            if '解析图片' in question or '分析图片' in question:
                session['waiting_for_image'] = True
                return JsonResponse({
                    'status': 'success',
                    'response': {
                        'result': '好的，请上传您想解析的图片，我会帮您详细分析。',
                        'waiting_for_image': True
                    }
                })

            # 创建不使用代理的session
            api_session = requests.Session()
            api_session.trust_env = False

            # 获取access token
            api_key = settings.WENXIN_API_KEY
            secret_key = settings.WENXIN_SECRET_KEY
            token_url = f"https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id={api_key}&client_secret={secret_key}"

            try:
                token_response = api_session.post(token_url)
                token_response.raise_for_status()
                access_token = token_response.json().get('access_token')

                if not access_token:
                    raise ValueError("Failed to get access token from response")

            except requests.exceptions.RequestException as e:
                logger.error(f"Error getting access token: {str(e)}")
                return JsonResponse({
                    'status': 'error',
                    'message': f"Failed to get access token: {str(e)}"
                }, status=500)

            # 调用文心一言API
            wenxin_url = f"https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions?access_token={access_token}"

            headers = {
                'Content-Type': 'application/json'
            }

            # 构建消息历史
            messages = session.get('context', [])
            messages.append({
                "role": "user",
                "content": question
            })

            payload = {
                "messages": messages,
                "stream": False,
                "temperature": 0.95,
                "top_p": 0.8
            }

            try:
                response = api_session.post(wenxin_url, headers=headers, json=payload)
                response.raise_for_status()
                result = response.json()

                # 保存AI的回复到上下文
                if result.get('result'):
                    messages.append({
                        "role": "assistant",
                        "content": result['result']
                    })
                    # 限制上下文长度，防止过长
                    if len(messages) > 10:
                        messages = messages[-10:]
                    session['context'] = messages

                return JsonResponse({
                    'status': 'success',
                    'response': result
                })

            except requests.exceptions.RequestException as e:
                logger.error(f"Error calling Wenxin API: {str(e)}")
                return JsonResponse({
                    'status': 'error',
                    'message': f"Failed to call Wenxin API: {str(e)}"
                }, status=500)

        except json.JSONDecodeError as e:
            logger.error(f"Invalid JSON in request: {str(e)}")
            return JsonResponse({
                'status': 'error',
                'message': 'Invalid JSON in request body'
            }, status=400)
        except Exception as e:
            logger.error(f"Unexpected error: {str(e)}")
            return JsonResponse({
                'status': 'error',
                'message': str(e)
            }, status=500)

    return JsonResponse({
        'status': 'error',
        'message': 'Only POST method is allowed'
    }, status=405)

# 图片解析
@csrf_exempt
def wenxin_image_analysis(request):
    if request.method == 'POST':
        try:
            session_id = request.POST.get('session_id', 'default')

            # 检查是否有文件上传
            if len(request.FILES) == 0:
                return JsonResponse({
                    'status': 'error',
                    'message': 'No file uploaded'
                }, status=400)

            image_file = request.FILES.get('image')
            if not image_file:
                return JsonResponse({
                    'status': 'error',
                    'message': 'No image file found in request'
                }, status=400)

            # 验证文件类型
            allowed_types = ['image/jpeg', 'image/png', 'image/gif', 'image/bmp']
            if image_file.content_type not in allowed_types:
                return JsonResponse({
                    'status': 'error',
                    'message': 'Invalid file type. Only images are allowed.'
                }, status=400)

            # 读取图片文件并转换为base64
            try:
                image_data = base64.b64encode(image_file.read()).decode('utf-8')
            except Exception as e:
                logger.error(f"Error encoding image: {str(e)}")
                return JsonResponse({
                    'status': 'error',
                    'message': 'Error processing image file'
                }, status=500)

            # 创建不使用代理的session
            session = requests.Session()
            session.trust_env = False

            # 获取access token
            api_key = settings.WENXIN_API_KEY
            secret_key = settings.WENXIN_SECRET_KEY
            token_url = f"https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id={api_key}&client_secret={secret_key}"

            try:
                token_response = session.post(token_url)
                token_response.raise_for_status()
                access_token = token_response.json().get('access_token')

                if not access_token:
                    raise ValueError("Failed to get access token from response")

            except requests.exceptions.RequestException as e:
                logger.error(f"Error getting access token: {str(e)}")
                return JsonResponse({
                    'status': 'error',
                    'message': f"Failed to get access token: {str(e)}"
                }, status=500)

            # 调用文心一言图像识别API
            wenxin_url = f"https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions_pro?access_token={access_token}"

            headers = {
                'Content-Type': 'application/json'
            }

            # 获取会话上下文
            session_data = user_sessions.get(session_id, {
                'waiting_for_image': False,
                'context': []
            })

            messages = session_data.get('context', [])

            payload = {
                "messages": [
                    {
                        "role": "user",
                        "content": "请详细分析这张图片的内容，包括图片中的主要元素、场景、风格特点等。",
                        "image_base64": f"data:image/jpeg;base64,{image_data}"
                    }
                ],
                "stream": False,
                "temperature": 0.95,
                "top_p": 0.8
            }

            try:
                response = session.post(wenxin_url, headers=headers, json=payload)
                response.raise_for_status()
                result = response.json()

                # 重置等待图片状态
                if session_id in user_sessions:
                    user_sessions[session_id]['waiting_for_image'] = False

                # 保存分析结果到对话上下文
                if result.get('result'):
                    messages.extend([
                        {"role": "user", "content": "请分析这张图片"},
                        {"role": "assistant", "content": result['result']}
                    ])
                    # 限制上下文长度
                    if len(messages) > 10:
                        messages = messages[-10:]
                    session_data['context'] = messages
                    user_sessions[session_id] = session_data

                return JsonResponse({
                    'status': 'success',
                    'response': result
                })

            except requests.exceptions.RequestException as e:
                logger.error(f"Error calling Wenxin Image API: {str(e)}")
                return JsonResponse({
                    'status': 'error',
                    'message': f"Failed to call Wenxin Image API: {str(e)}"
                }, status=500)

        except Exception as e:
            logger.error(f"Unexpected error in image analysis: {str(e)}")
            return JsonResponse({
                'status': 'error',
                'message': str(e)
            }, status=500)

    return JsonResponse({
        'status': 'error',
        'message': 'Only POST method is allowed'
    }, status=405)


# Deepseek聊天接口
@csrf_exempt
def deepseek_chat(request):
    if request.method == 'POST':
        try:
            data = json.loads(request.body)
            message = data.get('message', '')
            conversation_id = data.get('conversation_id', None)
            
            # Deepseek API配置
            api_key = settings.DEEP_SEEK_API
            headers = {
                'Authorization': f'Bearer {api_key}',
                'Content-Type': 'application/json'
            }
            
            # API endpoint
            url = 'https://api.deepseek.com/v1/chat/completions'
            
            # 准备请求数据
            payload = {
                'model': 'deepseek-chat',
                'messages': [
                    {'role': 'user', 'content': message}
                ],
                'temperature': 0.7,
                'max_tokens': 1000
            }
            
            # 如果有对话ID，可以用于后续实现对话历史功能
            if conversation_id:
                # 这里可以添加从数据库获取历史对话的逻辑
                pass
            
            # 发送请求到Deepseek API
            response = requests.post(url, headers=headers, json=payload)
            response.raise_for_status()
            
            # 解析响应
            result = response.json()
            
            # 提取AI的回复并移除所有星号
            ai_response = result.get('choices', [{}])[0].get('message', {}).get('content', '')
            # 直接移除所有星号
            ai_response = ai_response.replace('*', '')
            
            return JsonResponse({
                'status': 'success',
                'response': ai_response,
                'conversation_id': conversation_id
            })
            
        except requests.exceptions.RequestException as e:
            return JsonResponse({
                'status': 'error',
                'message': f'API request failed: {str(e)}'
            }, status=500)
            
        except json.JSONDecodeError:
            return JsonResponse({
                'status': 'error',
                'message': 'Invalid JSON in request body'
            }, status=400)
            
        except Exception as e:
            return JsonResponse({
                'status': 'error',
                'message': f'An unexpected error occurred: {str(e)}'
            }, status=500)
    
    return JsonResponse({
        'status': 'error',
        'message': 'Only POST method is allowed'
    }, status=405)
